
// Correction constant value: 2.67177820205688e-05 (0000000000000010)

module lim_arr_1212124 (Z2, X, Y);
	
	input [11:0] Y;
	input [11:0] X;
	output [11:0] Z2;


	wire [11:0] P0;
	wire [11:0] carry1;
	wire [11:0] sum1;
	wire [11:0] P1;
	wire [11:0] carry2;
	wire [11:0] sum2;
	wire [11:0] P2;
	wire [11:0] carry3;
	wire [11:0] sum3;
	wire [11:0] P3;
	wire [11:0] carry4;
	wire [11:0] sum4;
	wire [11:0] P4;
	wire [11:0] carry5;
	wire [11:0] sum5;
	wire [11:0] P5;
	wire [11:0] carry6;
	wire [11:0] sum6;
	wire [11:0] P6;
	wire [11:0] carry7;
	wire [11:0] sum7;
	wire [11:0] P7;
	wire [11:0] carry8;
	wire [11:0] sum8;
	wire [11:0] P8;
	wire [11:0] carry9;
	wire [11:0] sum9;
	wire [11:0] P9;
	wire [11:0] carry10;
	wire [11:0] sum10;
	wire [11:0] P10;
	wire [11:0] carry11;
	wire [11:0] sum11;
	wire [11:0] P11;
	wire [11:0] carry12;
	wire [11:0] sum12;
	wire [14:0] carry13;
	wire [15:0] Z;


	// generate the partial products.
	and pp1(P0[11], X[11], Y[0]);
	and pp2(P0[10], X[10], Y[0]);
	and pp3(P0[9], X[9], Y[0]);
	and pp4(P0[8], X[8], Y[0]);
	and pp5(sum1[11], X[11], Y[1]);
	and pp6(P1[10], X[10], Y[1]);
	and pp7(P1[9], X[9], Y[1]);
	and pp8(P1[8], X[8], Y[1]);
	and pp9(P1[7], X[7], Y[1]);
	and pp10(sum2[11], X[11], Y[2]);
	and pp11(P2[10], X[10], Y[2]);
	and pp12(P2[9], X[9], Y[2]);
	and pp13(P2[8], X[8], Y[2]);
	and pp14(P2[7], X[7], Y[2]);
	and pp15(P2[6], X[6], Y[2]);
	and pp16(sum3[11], X[11], Y[3]);
	and pp17(P3[10], X[10], Y[3]);
	and pp18(P3[9], X[9], Y[3]);
	and pp19(P3[8], X[8], Y[3]);
	and pp20(P3[7], X[7], Y[3]);
	and pp21(P3[6], X[6], Y[3]);
	and pp22(P3[5], X[5], Y[3]);
	and pp23(sum4[11], X[11], Y[4]);
	and pp24(P4[10], X[10], Y[4]);
	and pp25(P4[9], X[9], Y[4]);
	and pp26(P4[8], X[8], Y[4]);
	and pp27(P4[7], X[7], Y[4]);
	and pp28(P4[6], X[6], Y[4]);
	and pp29(P4[5], X[5], Y[4]);
	and pp30(P4[4], X[4], Y[4]);
	and pp31(sum5[11], X[11], Y[5]);
	and pp32(P5[10], X[10], Y[5]);
	and pp33(P5[9], X[9], Y[5]);
	and pp34(P5[8], X[8], Y[5]);
	and pp35(P5[7], X[7], Y[5]);
	and pp36(P5[6], X[6], Y[5]);
	and pp37(P5[5], X[5], Y[5]);
	and pp38(P5[4], X[4], Y[5]);
	and pp39(P5[3], X[3], Y[5]);
	and pp40(sum6[11], X[11], Y[6]);
	and pp41(P6[10], X[10], Y[6]);
	and pp42(P6[9], X[9], Y[6]);
	and pp43(P6[8], X[8], Y[6]);
	and pp44(P6[7], X[7], Y[6]);
	and pp45(P6[6], X[6], Y[6]);
	and pp46(P6[5], X[5], Y[6]);
	and pp47(P6[4], X[4], Y[6]);
	and pp48(P6[3], X[3], Y[6]);
	and pp49(P6[2], X[2], Y[6]);
	and pp50(sum7[11], X[11], Y[7]);
	and pp51(P7[10], X[10], Y[7]);
	and pp52(P7[9], X[9], Y[7]);
	and pp53(P7[8], X[8], Y[7]);
	and pp54(P7[7], X[7], Y[7]);
	and pp55(P7[6], X[6], Y[7]);
	and pp56(P7[5], X[5], Y[7]);
	and pp57(P7[4], X[4], Y[7]);
	and pp58(P7[3], X[3], Y[7]);
	and pp59(P7[2], X[2], Y[7]);
	and pp60(P7[1], X[1], Y[7]);
	and pp61(sum8[11], X[11], Y[8]);
	and pp62(P8[10], X[10], Y[8]);
	and pp63(P8[9], X[9], Y[8]);
	and pp64(P8[8], X[8], Y[8]);
	and pp65(P8[7], X[7], Y[8]);
	and pp66(P8[6], X[6], Y[8]);
	and pp67(P8[5], X[5], Y[8]);
	and pp68(P8[4], X[4], Y[8]);
	and pp69(P8[3], X[3], Y[8]);
	and pp70(P8[2], X[2], Y[8]);
	and pp71(P8[1], X[1], Y[8]);
	and pp72(P8[0], X[0], Y[8]);
	and pp73(sum9[11], X[11], Y[9]);
	and pp74(P9[10], X[10], Y[9]);
	and pp75(P9[9], X[9], Y[9]);
	and pp76(P9[8], X[8], Y[9]);
	and pp77(P9[7], X[7], Y[9]);
	and pp78(P9[6], X[6], Y[9]);
	and pp79(P9[5], X[5], Y[9]);
	and pp80(P9[4], X[4], Y[9]);
	and pp81(P9[3], X[3], Y[9]);
	and pp82(P9[2], X[2], Y[9]);
	and pp83(P9[1], X[1], Y[9]);
	and pp84(P9[0], X[0], Y[9]);
	and pp85(sum10[11], X[11], Y[10]);
	and pp86(P10[10], X[10], Y[10]);
	and pp87(P10[9], X[9], Y[10]);
	and pp88(P10[8], X[8], Y[10]);
	and pp89(P10[7], X[7], Y[10]);
	and pp90(P10[6], X[6], Y[10]);
	and pp91(P10[5], X[5], Y[10]);
	and pp92(P10[4], X[4], Y[10]);
	and pp93(P10[3], X[3], Y[10]);
	and pp94(P10[2], X[2], Y[10]);
	and pp95(P10[1], X[1], Y[10]);
	and pp96(P10[0], X[0], Y[10]);
	and pp97(sum11[11], X[11], Y[11]);
	and pp98(P11[10], X[10], Y[11]);
	and pp99(P11[9], X[9], Y[11]);
	and pp100(P11[8], X[8], Y[11]);
	and pp101(P11[7], X[7], Y[11]);
	and pp102(P11[6], X[6], Y[11]);
	and pp103(P11[5], X[5], Y[11]);
	and pp104(P11[4], X[4], Y[11]);
	and pp105(P11[3], X[3], Y[11]);
	and pp106(P11[2], X[2], Y[11]);
	and pp107(P11[1], X[1], Y[11]);
	and pp108(P11[0], X[0], Y[11]);

	// Array Reduction
	half_adder  HA1(carry1[10],sum1[10],P1[10],P0[11]);
	half_adder  HA2(carry1[9],sum1[9],P1[9],P0[10]);
	specialized_half_adder  SHA(carry1[8],sum1[8],P1[8],P0[9]);
	half_adder  HA3(carry1[7],sum1[7],P1[7],P0[8]);
	full_adder  FA1(carry2[10],sum2[10],P2[10],sum1[11],carry1[10]);
	full_adder  FA2(carry2[9],sum2[9],P2[9],sum1[10],carry1[9]);
	full_adder  FA3(carry2[8],sum2[8],P2[8],sum1[9],carry1[8]);
	full_adder  FA4(carry2[7],sum2[7],P2[7],sum1[8],carry1[7]);
	half_adder  HA4(carry2[6],sum2[6],P2[6],sum1[7]);
	full_adder  FA5(carry3[10],sum3[10],P3[10],sum2[11],carry2[10]);
	full_adder  FA6(carry3[9],sum3[9],P3[9],sum2[10],carry2[9]);
	full_adder  FA7(carry3[8],sum3[8],P3[8],sum2[9],carry2[8]);
	full_adder  FA8(carry3[7],sum3[7],P3[7],sum2[8],carry2[7]);
	full_adder  FA9(carry3[6],sum3[6],P3[6],sum2[7],carry2[6]);
	half_adder  HA5(carry3[5],sum3[5],P3[5],sum2[6]);
	full_adder  FA10(carry4[10],sum4[10],P4[10],sum3[11],carry3[10]);
	full_adder  FA11(carry4[9],sum4[9],P4[9],sum3[10],carry3[9]);
	full_adder  FA12(carry4[8],sum4[8],P4[8],sum3[9],carry3[8]);
	full_adder  FA13(carry4[7],sum4[7],P4[7],sum3[8],carry3[7]);
	full_adder  FA14(carry4[6],sum4[6],P4[6],sum3[7],carry3[6]);
	full_adder  FA15(carry4[5],sum4[5],P4[5],sum3[6],carry3[5]);
	half_adder  HA6(carry4[4],sum4[4],P4[4],sum3[5]);
	full_adder  FA16(carry5[10],sum5[10],P5[10],sum4[11],carry4[10]);
	full_adder  FA17(carry5[9],sum5[9],P5[9],sum4[10],carry4[9]);
	full_adder  FA18(carry5[8],sum5[8],P5[8],sum4[9],carry4[8]);
	full_adder  FA19(carry5[7],sum5[7],P5[7],sum4[8],carry4[7]);
	full_adder  FA20(carry5[6],sum5[6],P5[6],sum4[7],carry4[6]);
	full_adder  FA21(carry5[5],sum5[5],P5[5],sum4[6],carry4[5]);
	full_adder  FA22(carry5[4],sum5[4],P5[4],sum4[5],carry4[4]);
	half_adder  HA7(carry5[3],sum5[3],P5[3],sum4[4]);
	full_adder  FA23(carry6[10],sum6[10],P6[10],sum5[11],carry5[10]);
	full_adder  FA24(carry6[9],sum6[9],P6[9],sum5[10],carry5[9]);
	full_adder  FA25(carry6[8],sum6[8],P6[8],sum5[9],carry5[8]);
	full_adder  FA26(carry6[7],sum6[7],P6[7],sum5[8],carry5[7]);
	full_adder  FA27(carry6[6],sum6[6],P6[6],sum5[7],carry5[6]);
	full_adder  FA28(carry6[5],sum6[5],P6[5],sum5[6],carry5[5]);
	full_adder  FA29(carry6[4],sum6[4],P6[4],sum5[5],carry5[4]);
	full_adder  FA30(carry6[3],sum6[3],P6[3],sum5[4],carry5[3]);
	half_adder  HA8(carry6[2],sum6[2],P6[2],sum5[3]);
	full_adder  FA31(carry7[10],sum7[10],P7[10],sum6[11],carry6[10]);
	full_adder  FA32(carry7[9],sum7[9],P7[9],sum6[10],carry6[9]);
	full_adder  FA33(carry7[8],sum7[8],P7[8],sum6[9],carry6[8]);
	full_adder  FA34(carry7[7],sum7[7],P7[7],sum6[8],carry6[7]);
	full_adder  FA35(carry7[6],sum7[6],P7[6],sum6[7],carry6[6]);
	full_adder  FA36(carry7[5],sum7[5],P7[5],sum6[6],carry6[5]);
	full_adder  FA37(carry7[4],sum7[4],P7[4],sum6[5],carry6[4]);
	full_adder  FA38(carry7[3],sum7[3],P7[3],sum6[4],carry6[3]);
	full_adder  FA39(carry7[2],sum7[2],P7[2],sum6[3],carry6[2]);
	half_adder  HA9(carry7[1],sum7[1],P7[1],sum6[2]);
	full_adder  FA40(carry8[10],sum8[10],P8[10],sum7[11],carry7[10]);
	full_adder  FA41(carry8[9],sum8[9],P8[9],sum7[10],carry7[9]);
	full_adder  FA42(carry8[8],sum8[8],P8[8],sum7[9],carry7[8]);
	full_adder  FA43(carry8[7],sum8[7],P8[7],sum7[8],carry7[7]);
	full_adder  FA44(carry8[6],sum8[6],P8[6],sum7[7],carry7[6]);
	full_adder  FA45(carry8[5],sum8[5],P8[5],sum7[6],carry7[5]);
	full_adder  FA46(carry8[4],sum8[4],P8[4],sum7[5],carry7[4]);
	full_adder  FA47(carry8[3],sum8[3],P8[3],sum7[4],carry7[3]);
	full_adder  FA48(carry8[2],sum8[2],P8[2],sum7[3],carry7[2]);
	full_adder  FA49(carry8[1],sum8[1],P8[1],sum7[2],carry7[1]);
	assign carry8[0] = P8[0] & sum7[1];
	full_adder  FA50(carry9[10],sum9[10],P9[10],sum8[11],carry8[10]);
	full_adder  FA51(carry9[9],sum9[9],P9[9],sum8[10],carry8[9]);
	full_adder  FA52(carry9[8],sum9[8],P9[8],sum8[9],carry8[8]);
	full_adder  FA53(carry9[7],sum9[7],P9[7],sum8[8],carry8[7]);
	full_adder  FA54(carry9[6],sum9[6],P9[6],sum8[7],carry8[6]);
	full_adder  FA55(carry9[5],sum9[5],P9[5],sum8[6],carry8[5]);
	full_adder  FA56(carry9[4],sum9[4],P9[4],sum8[5],carry8[4]);
	full_adder  FA57(carry9[3],sum9[3],P9[3],sum8[4],carry8[3]);
	full_adder  FA58(carry9[2],sum9[2],P9[2],sum8[3],carry8[2]);
	full_adder  FA59(carry9[1],sum9[1],P9[1],sum8[2],carry8[1]);
	reduced_full_adder  RFA(carry9[0],P9[0],sum8[1],carry8[0]);
	full_adder  FA60(carry10[10],sum10[10],P10[10],sum9[11],carry9[10]);
	full_adder  FA61(carry10[9],sum10[9],P10[9],sum9[10],carry9[9]);
	full_adder  FA62(carry10[8],sum10[8],P10[8],sum9[9],carry9[8]);
	full_adder  FA63(carry10[7],sum10[7],P10[7],sum9[8],carry9[7]);
	full_adder  FA64(carry10[6],sum10[6],P10[6],sum9[7],carry9[6]);
	full_adder  FA65(carry10[5],sum10[5],P10[5],sum9[6],carry9[5]);
	full_adder  FA66(carry10[4],sum10[4],P10[4],sum9[5],carry9[4]);
	full_adder  FA67(carry10[3],sum10[3],P10[3],sum9[4],carry9[3]);
	full_adder  FA68(carry10[2],sum10[2],P10[2],sum9[3],carry9[2]);
	full_adder  FA69(carry10[1],sum10[1],P10[1],sum9[2],carry9[1]);
	reduced_full_adder  RFA1(carry10[0],P10[0],sum9[1],carry9[0]);
	full_adder  FA70(carry11[10],sum11[10],P11[10],sum10[11],carry10[10]);
	full_adder  FA71(carry11[9],sum11[9],P11[9],sum10[10],carry10[9]);
	full_adder  FA72(carry11[8],sum11[8],P11[8],sum10[9],carry10[8]);
	full_adder  FA73(carry11[7],sum11[7],P11[7],sum10[8],carry10[7]);
	full_adder  FA74(carry11[6],sum11[6],P11[6],sum10[7],carry10[6]);
	full_adder  FA75(carry11[5],sum11[5],P11[5],sum10[6],carry10[5]);
	full_adder  FA76(carry11[4],sum11[4],P11[4],sum10[5],carry10[4]);
	full_adder  FA77(carry11[3],sum11[3],P11[3],sum10[4],carry10[3]);
	full_adder  FA78(carry11[2],sum11[2],P11[2],sum10[3],carry10[2]);
	full_adder  FA79(carry11[1],sum11[1],P11[1],sum10[2],carry10[1]);
	reduced_full_adder  RFA2(carry11[0],P11[0],sum10[1],carry10[0]);

	// Generate lower product bits YBITS 

	// Final Carry Propagate Addition
	//   Generate higher product bits
	half_adder CPA1(carry12[0],Z2[0],carry11[0],sum11[1]);
	full_adder CPA2(carry12[1],Z2[1],carry11[1],carry12[0],sum11[2]);
	full_adder CPA3(carry12[2],Z2[2],carry11[2],carry12[1],sum11[3]);
	full_adder CPA4(carry12[3],Z2[3],carry11[3],carry12[2],sum11[4]);
	full_adder CPA5(carry12[4],Z2[4],carry11[4],carry12[3],sum11[5]);
	full_adder CPA6(carry12[5],Z2[5],carry11[5],carry12[4],sum11[6]);
	full_adder CPA7(carry12[6],Z2[6],carry11[6],carry12[5],sum11[7]);
	full_adder CPA8(carry12[7],Z2[7],carry11[7],carry12[6],sum11[8]);
	full_adder CPA9(carry12[8],Z2[8],carry11[8],carry12[7],sum11[9]);
	full_adder CPA10(carry12[9],Z2[9],carry11[9],carry12[8],sum11[10]);
	full_adder CPA11(Z2[11],Z2[10],carry11[10],carry12[9],sum11[11]);
endmodule